import java.util.Arrays;

public class MyArrayList  {
   public int [] elem; //只定义了一个int[]类型的数组，未将其初始化
   public int usedSize;//记录数组中元素的有效个数
    //用构造方法将数组初始化
    public MyArrayList(){
        this.elem=new int[Constant.DEFAULT_SIZE];
    }
   public void add(int data){
      //1.判断顺序表是否满了
       if(isFull()){
           grow();
       }
       this.elem[usedSize]=data;
       usedSize++;
   }
   //将顺序表中的元素全部展示出来
   public void display(){
       for (int i = 0; i < usedSize; i++) {
           System.out.println(elem[i]);
       }
   }
   //求顺序表中元素的个数
    public int size(){
        return this.usedSize;//顺序表中元素的个数就是顺序表有效元素的个数
    }
    //顺序表中是否包含我要找的元素
    public boolean contains(int toFind){
        for (int i = 0; i < usedSize; i++) {
            if(elem[i]==toFind){
                return true;
            }
        }
        //走到这说明将顺序表中的元素全部都遍历了一遍，并且没有进入if(),也就是说顺序表中并没有我要找的元素
        return false;
    }
    //顺序表中是否有我要找的元素，有就返回下标i,没有就返回-1
    public int indexOf(int toFind){
        for (int i = 0; i < usedSize; i++) {
            if(elem[i]==toFind){
                return i;
            }
        }
        return -1;
    }
    //通过下标，返回下标所对应的值
    public int get(int pos){
        //1.判断数组是否为空
        if(isEmpty()){
           throw new EmptyException(Constant.EMPTY_LIST) ;
        }
        String msg=Constant.GET_POS_ILLEGALITY;
        //2.判断下表的合法性
        checkPos(pos,msg);
        return elem[pos];
    }
    //往任意位置插入新的数据
    public void add(int pos,int data){
        //1.判断是否满了
        if(isFull()){
            grow();
        }
        String msg=Constant.ADD_POS_ILLEGALITY;
        //2.判断下表的合法性
        checkAddPos(pos,msg);
        //3.插入的位置为usedSize
        if(pos==usedSize){
            elem[usedSize]=data;
            usedSize++;
            return;
        }
        for (int i = usedSize-1; i >=pos ; i--) {
            elem[i+1]=elem[i];
        }
        elem[pos]=data;
        usedSize++;
    }
    //删除元素(以覆盖的方式)
   public void remove(int data){
        //1.判断顺序表是否为空
       if(isEmpty()){
           throw new EmptyException(Constant.EMPTY_LIST);
       }
       //2.要删除的那个元素顺序表中中是否包含
       int iy=indexOf(data);
       //如果返回值为-1，说明没有我要删除的元素
       if(iy==-1){
           System.out.println("没有你要删除的元素");
           return;
       }
       for (int i = iy; i < usedSize-1; i++) {
           elem[i]=elem[i+1];
       }
       usedSize--;
   }
   //更改元素的数值
   public void set(int pos,int value){
        //1.判断顺序表是否为空
       if(isEmpty()){
           throw new EmptyException(Constant.EMPTY_LIST);
       }
       String msg=Constant.SET_POS_ILLEGALITY;
       //2.检查pos位置的合法性
       checkSetPos(pos,msg);
       elem[pos]=value;
   }
   //清空顺序表中所有的元素
   public void clear(){
       for (int i = 0; i < usedSize; i++) {
           elem[i]=0;
       }
       usedSize=0;
   }

    private void checkSetPos(int pos, String msg) {
        if (pos<0||pos>=usedSize){
            throw new PosIllegalityException(msg);
        }
    }

    private void checkAddPos(int pos,String msg) {
        if(pos<0||pos>usedSize){
            throw new PosIllegalityException(msg);
        }
    }

    private void checkPos(int pos,String msg) {
        if(pos<0||pos>=usedSize){
            throw new PosIllegalityException(msg);
        }
    }

    //判断是否为空
    public boolean isEmpty(){
        return usedSize==0;
    }
   //用isFull()方法来判断数组满没满
   public boolean isFull(){
        return this.usedSize== this.elem.length;
   }
   //在grow()方法中调用Arrays.copyOf()将数组扩容(2倍扩容)
  public void grow(){
        this.elem= Arrays.copyOf(this.elem,2*this.elem.length);
  }
}
